home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / UNIX / PASCAL / PTOC / PTC_C.2 < prev    next >
Text File  |  1992-11-23  |  35KB  |  1,501 lines
  1.             tf = typnods.A[(int)(tset)];
  2.             break ;
  3.           case nselect:
  4.             tq = tq->U.V40.tfield;
  5.             break ;
  6.           case nderef:
  7.             tq = typeof(tq->U.V42.texps);
  8.             switch (tq->tt) {
  9.               case nptr:
  10.                 tq = tq->U.V16.tptrid;
  11.                 break ;
  12.               case nfileof:
  13.                 tq = tq->U.V18.tof;
  14.                 break ;
  15.               case npredef:
  16.                 tf = typnods.A[(int)(tchar)];
  17.                 break ;
  18.               default:
  19.                 Caseerror(Line);
  20.             }
  21.             break ;
  22.           case nindex:
  23.             tq = typeof(tq->U.V39.tvariable);
  24.             if (tq->tt == nconfarr)
  25.                 tq = tq->U.V22.tcelem;
  26.             else
  27.                 if (tq == typnods.A[(int)(tstring)])
  28.                     tf = typnods.A[(int)(tchar)];
  29.                 else
  30.                     tq = tq->U.V23.taelem;
  31.             break ;
  32.           default:
  33.             Caseerror(Line);
  34.         }
  35.     }
  36.     if (tp->ttype == (struct S61 *)NIL)
  37.         tp->ttype = tf;
  38.     R92 = tf;
  39.     return R92;
  40. }
  41.  
  42.  void
  43. linkup(up, tp)
  44.     treeptr    up, tp;
  45. {
  46.     while (tp != (struct S61 *)NIL) {
  47.         if (tp->tup == (struct S61 *)NIL) {
  48.             tp->tup = up;
  49.             switch (tp->tt) {
  50.               case npgm:  case nfunc:  case nproc:
  51.                 linkup(tp, tp->U.V13.tsubid);
  52.                 linkup(tp, tp->U.V13.tsubpar);
  53.                 linkup(tp, tp->U.V13.tfuntyp);
  54.                 linkup(tp, tp->U.V13.tsublab);
  55.                 linkup(tp, tp->U.V13.tsubconst);
  56.                 linkup(tp, tp->U.V13.tsubtype);
  57.                 linkup(tp, tp->U.V13.tsubvar);
  58.                 linkup(tp, tp->U.V13.tsubsub);
  59.                 linkup(tp, tp->U.V13.tsubstmt);
  60.                 break ;
  61.               case nvalpar:  case nvarpar:  case nconst:  case ntype:
  62.               case nfield:  case nvar:
  63.                 linkup(tp, tp->U.V14.tidl);
  64.                 linkup(tp, tp->U.V14.tbind);
  65.                 break ;
  66.               case nparproc:  case nparfunc:
  67.                 linkup(tp, tp->U.V15.tparid);
  68.                 linkup(tp, tp->U.V15.tparparm);
  69.                 linkup(tp, tp->U.V15.tpartyp);
  70.                 break ;
  71.               case nptr:
  72.                 linkup(tp, tp->U.V16.tptrid);
  73.                 break ;
  74.               case nscalar:
  75.                 linkup(tp, tp->U.V17.tscalid);
  76.                 break ;
  77.               case nsubrange:
  78.                 linkup(tp, tp->U.V19.tlo);
  79.                 linkup(tp, tp->U.V19.thi);
  80.                 break ;
  81.               case nvariant:
  82.                 linkup(tp, tp->U.V20.tselct);
  83.                 linkup(tp, tp->U.V20.tvrnt);
  84.                 break ;
  85.               case nrecord:
  86.                 linkup(tp, tp->U.V21.tflist);
  87.                 linkup(tp, tp->U.V21.tvlist);
  88.                 break ;
  89.               case nconfarr:
  90.                 linkup(tp, tp->U.V22.tcindx);
  91.                 linkup(tp, tp->U.V22.tcelem);
  92.                 linkup(tp, tp->U.V22.tindtyp);
  93.                 break ;
  94.               case narray:
  95.                 linkup(tp, tp->U.V23.taindx);
  96.                 linkup(tp, tp->U.V23.taelem);
  97.                 break ;
  98.               case nfileof:  case nsetof:
  99.                 linkup(tp, tp->U.V18.tof);
  100.                 break ;
  101.               case nbegin:
  102.                 linkup(tp, tp->U.V24.tbegin);
  103.                 break ;
  104.               case nlabstmt:
  105.                 linkup(tp, tp->U.V25.tlabno);
  106.                 linkup(tp, tp->U.V25.tstmt);
  107.                 break ;
  108.               case nassign:
  109.                 linkup(tp, tp->U.V27.tlhs);
  110.                 linkup(tp, tp->U.V27.trhs);
  111.                 break ;
  112.               case npush:  case npop:
  113.                 linkup(tp, tp->U.V28.tglob);
  114.                 linkup(tp, tp->U.V28.tloc);
  115.                 linkup(tp, tp->U.V28.ttmp);
  116.                 break ;
  117.               case ncall:
  118.                 linkup(tp, tp->U.V30.tcall);
  119.                 linkup(tp, tp->U.V30.taparm);
  120.                 break ;
  121.               case nif:
  122.                 linkup(tp, tp->U.V31.tifxp);
  123.                 linkup(tp, tp->U.V31.tthen);
  124.                 linkup(tp, tp->U.V31.telse);
  125.                 break ;
  126.               case nwhile:
  127.                 linkup(tp, tp->U.V32.twhixp);
  128.                 linkup(tp, tp->U.V32.twhistmt);
  129.                 break ;
  130.               case nrepeat:
  131.                 linkup(tp, tp->U.V33.treptstmt);
  132.                 linkup(tp, tp->U.V33.treptxp);
  133.                 break ;
  134.               case nfor:
  135.                 linkup(tp, tp->U.V34.tforid);
  136.                 linkup(tp, tp->U.V34.tfrom);
  137.                 linkup(tp, tp->U.V34.tto);
  138.                 linkup(tp, tp->U.V34.tforstmt);
  139.                 break ;
  140.               case ncase:
  141.                 linkup(tp, tp->U.V35.tcasxp);
  142.                 linkup(tp, tp->U.V35.tcaslst);
  143.                 linkup(tp, tp->U.V35.tcasother);
  144.                 break ;
  145.               case nchoise:
  146.                 linkup(tp, tp->U.V36.tchocon);
  147.                 linkup(tp, tp->U.V36.tchostmt);
  148.                 break ;
  149.               case nwith:
  150.                 linkup(tp, tp->U.V37.twithvar);
  151.                 linkup(tp, tp->U.V37.twithstmt);
  152.                 break ;
  153.               case nwithvar:
  154.                 linkup(tp, tp->U.V38.texpw);
  155.                 break ;
  156.               case nindex:
  157.                 linkup(tp, tp->U.V39.tvariable);
  158.                 linkup(tp, tp->U.V39.toffset);
  159.                 break ;
  160.               case nselect:
  161.                 linkup(tp, tp->U.V40.trecord);
  162.                 linkup(tp, tp->U.V40.tfield);
  163.                 break ;
  164.               case ngoto:
  165.                 linkup(tp, tp->U.V26.tlabel);
  166.                 break ;
  167.               case nrange:  case nformat:  case nin:  case neq:
  168.               case nne:  case nlt:  case nle:  case ngt:
  169.               case nge:  case nor:  case nplus:  case nminus:
  170.               case nand:  case nmul:  case ndiv:  case nmod:
  171.               case nquot:
  172.                 linkup(tp, tp->U.V41.texpl);
  173.                 linkup(tp, tp->U.V41.texpr);
  174.                 break ;
  175.               case nderef:  case nnot:  case nset:  case numinus:
  176.               case nuplus:
  177.                 linkup(tp, tp->U.V42.texps);
  178.                 break ;
  179.               case nid:  case nnil:  case ninteger:  case nreal:
  180.               case nchar:  case nstring:  case npredef:  case nlabel:
  181.               case nempty:
  182.                 break ;
  183.               default:
  184.                 Caseerror(Line);
  185.             }
  186.         }
  187.         tp = tp->tnext;
  188.     }
  189. }
  190.  
  191.  symptr
  192. mksym(vt)
  193.     ltypes    vt;
  194. {
  195.     register symptr    R93;
  196.     symptr    mp;
  197.  
  198.     mp = (struct S62 *)malloc((unsigned)(sizeof(*mp)));
  199.     if (mp == (struct S62 *)NIL)
  200.         error(enew);
  201.     mp->lt = vt;
  202.     mp->lnext = (struct S62 *)NIL;
  203.     mp->lsymdecl = (struct S61 *)NIL;
  204.     mp->ldecl = (struct S60 *)NIL;
  205.     R93 = mp;
  206.     return R93;
  207. }
  208.  
  209.  void
  210. declsym(sp)
  211.     symptr    sp;
  212. {
  213.     hashtyp    h;
  214.  
  215.     if (Member((unsigned)(sp->lt), Conset[1]))
  216.         h = sp->U.V6.lid->ihash;
  217.     else
  218.         h = hashmax;
  219.     sp->lnext = symtab->ddecl.A[h];
  220.     symtab->ddecl.A[h] = sp;
  221.     sp->ldecl = symtab;
  222. }
  223.  
  224.  treeptr
  225. mknode(nt)
  226.     treetyp    nt;
  227. {
  228.     register treeptr    R94;
  229.     treeptr    tp;
  230.  
  231.     tp = (struct S61 *)NIL;
  232.     switch (nt) {
  233.       case npredef:
  234.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V12.tdef) + sizeof(tp->U.V12)));
  235.         break ;
  236.       case npgm:
  237.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V13.tsubid) + sizeof(tp->U.V13)));
  238.         break ;
  239.       case nfunc:
  240.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V13.tsubid) + sizeof(tp->U.V13)));
  241.         break ;
  242.       case nproc:
  243.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V13.tsubid) + sizeof(tp->U.V13)));
  244.         break ;
  245.       case nlabel:
  246.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  247.         break ;
  248.       case nconst:
  249.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  250.         break ;
  251.       case ntype:
  252.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  253.         break ;
  254.       case nvar:
  255.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  256.         break ;
  257.       case nvalpar:
  258.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  259.         break ;
  260.       case nvarpar:
  261.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  262.         break ;
  263.       case nparproc:
  264.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V15.tparid) + sizeof(tp->U.V15)));
  265.         break ;
  266.       case nparfunc:
  267.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V15.tparid) + sizeof(tp->U.V15)));
  268.         break ;
  269.       case nsubrange:
  270.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V19.tlo) + sizeof(tp->U.V19)));
  271.         break ;
  272.       case nvariant:
  273.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V20.tselct) + sizeof(tp->U.V20)));
  274.         break ;
  275.       case nfield:
  276.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V14.tidl) + sizeof(tp->U.V14)));
  277.         break ;
  278.       case nrecord:
  279.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V21.tflist) + sizeof(tp->U.V21)));
  280.         break ;
  281.       case nconfarr:
  282.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V22.tcindx) + sizeof(tp->U.V22)));
  283.         break ;
  284.       case narray:
  285.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V23.taindx) + sizeof(tp->U.V23)));
  286.         break ;
  287.       case nfileof:
  288.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V18.tof) + sizeof(tp->U.V18)));
  289.         break ;
  290.       case nsetof:
  291.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V18.tof) + sizeof(tp->U.V18)));
  292.         break ;
  293.       case nbegin:
  294.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V24.tbegin) + sizeof(tp->U.V24)));
  295.         break ;
  296.       case nptr:
  297.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V16.tptrid) + sizeof(tp->U.V16)));
  298.         break ;
  299.       case nscalar:
  300.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V17.tscalid) + sizeof(tp->U.V17)));
  301.         break ;
  302.       case nif:
  303.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V31.tifxp) + sizeof(tp->U.V31)));
  304.         break ;
  305.       case nwhile:
  306.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V32.twhixp) + sizeof(tp->U.V32)));
  307.         break ;
  308.       case nrepeat:
  309.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V33.treptstmt) + sizeof(tp->U.V33)));
  310.         break ;
  311.       case nfor:
  312.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V34.tforid) + sizeof(tp->U.V34)));
  313.         break ;
  314.       case ncase:
  315.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V35.tcasxp) + sizeof(tp->U.V35)));
  316.         break ;
  317.       case nchoise:
  318.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V36.tchocon) + sizeof(tp->U.V36)));
  319.         break ;
  320.       case ngoto:
  321.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V26.tlabel) + sizeof(tp->U.V26)));
  322.         break ;
  323.       case nwith:
  324.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V37.twithvar) + sizeof(tp->U.V37)));
  325.         break ;
  326.       case nwithvar:
  327.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V38.texpw) + sizeof(tp->U.V38)));
  328.         break ;
  329.       case nempty:
  330.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V12.tdef)));
  331.         break ;
  332.       case nlabstmt:
  333.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V25.tlabno) + sizeof(tp->U.V25)));
  334.         break ;
  335.       case nassign:
  336.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V27.tlhs) + sizeof(tp->U.V27)));
  337.         break ;
  338.       case nformat:
  339.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  340.         break ;
  341.       case nin:
  342.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  343.         break ;
  344.       case neq:
  345.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  346.         break ;
  347.       case nne:
  348.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  349.         break ;
  350.       case nlt:
  351.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  352.         break ;
  353.       case nle:
  354.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  355.         break ;
  356.       case ngt:
  357.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  358.         break ;
  359.       case nge:
  360.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  361.         break ;
  362.       case nor:
  363.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  364.         break ;
  365.       case nplus:
  366.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  367.         break ;
  368.       case nminus:
  369.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  370.         break ;
  371.       case nand:
  372.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  373.         break ;
  374.       case nmul:
  375.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  376.         break ;
  377.       case ndiv:
  378.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  379.         break ;
  380.       case nmod:
  381.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  382.         break ;
  383.       case nquot:
  384.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  385.         break ;
  386.       case nnot:
  387.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V42.texps) + sizeof(tp->U.V42)));
  388.         break ;
  389.       case numinus:
  390.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V42.texps) + sizeof(tp->U.V42)));
  391.         break ;
  392.       case nuplus:
  393.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V42.texps) + sizeof(tp->U.V42)));
  394.         break ;
  395.       case nset:
  396.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V42.texps) + sizeof(tp->U.V42)));
  397.         break ;
  398.       case nrange:
  399.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V41.texpl) + sizeof(tp->U.V41)));
  400.         break ;
  401.       case nindex:
  402.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V39.tvariable) + sizeof(tp->U.V39)));
  403.         break ;
  404.       case nselect:
  405.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V40.trecord) + sizeof(tp->U.V40)));
  406.         break ;
  407.       case nderef:
  408.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V42.texps) + sizeof(tp->U.V42)));
  409.         break ;
  410.       case ncall:
  411.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V30.tcall) + sizeof(tp->U.V30)));
  412.         break ;
  413.       case nid:
  414.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  415.         break ;
  416.       case nchar:
  417.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  418.         break ;
  419.       case ninteger:
  420.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  421.         break ;
  422.       case nreal:
  423.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  424.         break ;
  425.       case nstring:
  426.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V43.tsym) + sizeof(tp->U.V43)));
  427.         break ;
  428.       case nnil:
  429.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V12.tdef)));
  430.         break ;
  431.       case npush:
  432.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V28.tglob) + sizeof(tp->U.V28)));
  433.         break ;
  434.       case npop:
  435.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V28.tglob) + sizeof(tp->U.V28)));
  436.         break ;
  437.       case nbreak:
  438.         tp = (struct S61 *)malloc((unsigned)(Unionoffs(tp, U.V29.tbrkid) + sizeof(tp->U.V29)));
  439.         break ;
  440.       default:
  441.         Caseerror(Line);
  442.     }
  443.     if (tp == (struct S61 *)NIL)
  444.         error(enew);
  445.     tp->tt = nt;
  446.     tp->tnext = (struct S61 *)NIL;
  447.     tp->tup = (struct S61 *)NIL;
  448.     tp->ttype = (struct S61 *)NIL;
  449.     R94 = tp;
  450.     return R94;
  451. }
  452.  
  453.  treeptr
  454. mklit()
  455. {
  456.     register treeptr    R95;
  457.     symptr    sp;
  458.     treeptr    tp;
  459.  
  460.     switch (currsym.st) {
  461.       case sinteger:
  462.         sp = mksym(linteger);
  463.         sp->U.V10.linum = currsym.U.V3.vint;
  464.         tp = mknode(ninteger);
  465.         break ;
  466.       case sreal:
  467.         sp = mksym(lreal);
  468.         sp->U.V8.lfloat = currsym.U.V4.vflt;
  469.         tp = mknode(nreal);
  470.         break ;
  471.       case schar:
  472.         sp = mksym(lcharacter);
  473.         sp->U.V11.lchar = currsym.U.V2.vchr;
  474.         tp = mknode(nchar);
  475.         break ;
  476.       case sstring:
  477.         sp = mksym(lstring);
  478.         sp->U.V7.lstr = currsym.U.V5.vstr;
  479.         tp = mknode(nstring);
  480.         break ;
  481.       default:
  482.         Caseerror(Line);
  483.     }
  484.     tp->U.V43.tsym = sp;
  485.     sp->lsymdecl = tp;
  486.     R95 = tp;
  487.     return R95;
  488. }
  489.  
  490.  symptr
  491. lookupid(ip, fieldok)
  492.     idptr    ip;
  493.     boolean    fieldok;
  494. {
  495.     register symptr    R96;
  496.     symptr    sp;
  497.     declptr    dp;
  498.     struct { setword    S[2]; }    vs;
  499.  
  500.     R96 = (struct S62 *)NIL;
  501.     if (fieldok)
  502.         Setncpy(vs.S, Conset[2], sizeof(vs.S));
  503.     else
  504.         Setncpy(vs.S, Conset[3], sizeof(vs.S));
  505.     sp = (struct S62 *)NIL;
  506.     dp = symtab;
  507.     while (dp != (struct S60 *)NIL) {
  508.         sp = dp->ddecl.A[ip->ihash];
  509.         while (sp != (struct S62 *)NIL) {
  510.             if ((Member((unsigned)(sp->lt), vs.S)) && (sp->U.V6.lid == ip))
  511.                 goto L999;
  512.             sp = sp->lnext;
  513.         }
  514.         dp = dp->dprev;
  515.     }
  516. L999:
  517.     R96 = sp;
  518.     return R96;
  519. }
  520.  
  521.  symptr
  522. lookuplabel(i)
  523.     integer    i;
  524. {
  525.     register symptr    R97;
  526.     symptr    sp;
  527.     declptr    dp;
  528.  
  529.     sp = (struct S62 *)NIL;
  530.     dp = symtab;
  531.     while (dp != (struct S60 *)NIL) {
  532.         sp = dp->ddecl.A[hashmax];
  533.         while (sp != (struct S62 *)NIL) {
  534.             if ((Member((unsigned)(sp->lt), Conset[4])) && (sp->U.V9.lno == i))
  535.                 goto L999;
  536.             sp = sp->lnext;
  537.         }
  538.         dp = dp->dprev;
  539.     }
  540. L999:
  541.     R97 = sp;
  542.     return R97;
  543. }
  544.  
  545.  void
  546. enterscope(dp)
  547.     declptr    dp;
  548. {
  549.     register hashtyp    h;
  550.  
  551.     if (dp == (struct S60 *)NIL) {
  552.         dp = (struct S60 *)malloc((unsigned)(sizeof(*dp)));
  553.         {
  554.             hashtyp    B47 = 0,
  555.                 B48 = hashmax;
  556.  
  557.             if (B47 <= B48)
  558.                 for (h = B47; ; h++) {
  559.                     dp->ddecl.A[h] = (struct S62 *)NIL;
  560.                     if (h == B48) break;
  561.                 }
  562.         }
  563.     }
  564.     dp->dprev = symtab;
  565.     symtab = dp;
  566. }
  567.  
  568.  declptr
  569. currscope()
  570. {
  571.     register declptr    R98;
  572.  
  573.     R98 = symtab;
  574.     return R98;
  575. }
  576.  
  577.  void
  578. leavescope()
  579. {
  580.     symtab = symtab->dprev;
  581. }
  582.  
  583.  symptr
  584. mkid(ip)
  585.     idptr    ip;
  586. {
  587.     register symptr    R99;
  588.     symptr    sp;
  589.  
  590.     sp = mksym(lidentifier);
  591.     sp->U.V6.lid = ip;
  592.     sp->U.V6.lused = false;
  593.     declsym(sp);
  594.     ip->inref = ip->inref + 1;
  595.     R99 = sp;
  596.     return R99;
  597. }
  598.  
  599.  treeptr
  600. newid(ip)
  601.     idptr    ip;
  602. {
  603.     register treeptr    R100;
  604.     symptr    sp;
  605.     treeptr    tp;
  606.  
  607.     sp = lookupid(ip, false);
  608.     if (sp != (struct S62 *)NIL)
  609.         if (sp->ldecl != symtab)
  610.             sp = (struct S62 *)NIL;
  611.     if (sp == (struct S62 *)NIL) {
  612.         tp = mknode(nid);
  613.         sp = mkid(ip);
  614.         sp->lsymdecl = tp;
  615.         tp->U.V43.tsym = sp;
  616.     } else
  617.         if (sp->lt == lpointer) {
  618.             tp = mknode(nid);
  619.             tp->U.V43.tsym = sp;
  620.             sp->lt = lidentifier;
  621.             sp->lsymdecl = tp;
  622.         } else
  623.             if (sp->lt == lforward) {
  624.                 sp->lt = lidentifier;
  625.                 tp = sp->lsymdecl;
  626.             } else
  627.                 error(emultdeclid);
  628.     R100 = tp;
  629.     return R100;
  630. }
  631.  
  632.  treeptr
  633. oldid(ip, l)
  634.     idptr    ip;
  635.     ltypes    l;
  636. {
  637.     register treeptr    R101;
  638.     symptr    sp;
  639.     treeptr    tp;
  640.  
  641.     sp = lookupid(ip, true);
  642.     if (sp == (struct S62 *)NIL) {
  643.         if (Member((unsigned)(l), Conset[5])) {
  644.             tp = newid(ip);
  645.             tp->U.V43.tsym->lt = l;
  646.         } else
  647.             error(enotdeclid);
  648.     } else {
  649.         sp->U.V6.lused = true;
  650.         tp = mknode(nid);
  651.         tp->U.V43.tsym = sp;
  652.         if ((sp->lt == lpointer) && (l == lidentifier)) {
  653.             sp->lt = lidentifier;
  654.             sp->lsymdecl = tp;
  655.         }
  656.     }
  657.     R101 = tp;
  658.     return R101;
  659. }
  660.  
  661.  treeptr
  662. oldfield(tp, ip)
  663.     treeptr    tp;
  664.     idptr    ip;
  665. {
  666.     register treeptr    R102;
  667.     treeptr    tq, ti, fp;
  668.  
  669.     fp = (struct S61 *)NIL;
  670.     tq = tp->U.V21.tflist;
  671.     while (tq != (struct S61 *)NIL) {
  672.         ti = tq->U.V14.tidl;
  673.         while (ti != (struct S61 *)NIL) {
  674.             if (ti->U.V43.tsym->U.V6.lid == ip) {
  675.                 fp = mknode(nid);
  676.                 fp->U.V43.tsym = ti->U.V43.tsym;
  677.                 goto L999;
  678.             }
  679.             ti = ti->tnext;
  680.         }
  681.         tq = tq->tnext;
  682.     }
  683.     tq = tp->U.V21.tvlist;
  684.     while (tq != (struct S61 *)NIL) {
  685.         fp = oldfield(tq->U.V20.tvrnt, ip);
  686.         if (fp != (struct S61 *)NIL)
  687.             tq = (struct S61 *)NIL;
  688.         else
  689.             tq = tq->tnext;
  690.     }
  691. L999:
  692.     R102 = fp;
  693.     return R102;
  694. }
  695.  
  696. void parse();
  697.  
  698. treeptr plabel();
  699.  
  700. treeptr pidlist();
  701.  
  702.  
  703. treeptr pconst();
  704.  
  705. treeptr pconstant();
  706.  
  707. treeptr precord();
  708.  
  709. treeptr ptypedef();
  710.  
  711. treeptr ptype();
  712.  
  713. treeptr pvar();
  714.  
  715. treeptr psubs();
  716.  
  717. treeptr psubpar();
  718.  
  719. treeptr plabstmt();
  720.  
  721. treeptr pstmt();
  722.  
  723. treeptr psimple();
  724.  
  725. treeptr pvariable();
  726.  
  727. treeptr pexpr();
  728.  
  729. treeptr pcase();
  730.  
  731. treeptr pif();
  732.  
  733. treeptr pwhile();
  734.  
  735. treeptr prepeat();
  736.  
  737. treeptr pfor();
  738.  
  739. treeptr pwith();
  740.  
  741. treeptr pgoto();
  742.  
  743. treeptr pbegin();
  744.  
  745. void scopeup();
  746.  
  747.  void
  748. addfields(rp)
  749.     treeptr    rp;
  750. {
  751.     treeptr    fp, ip, vp;
  752.     symptr    sp;
  753.  
  754.     fp = rp->U.V21.tflist;
  755.     while (fp != (struct S61 *)NIL) {
  756.         ip = fp->U.V14.tidl;
  757.         while (ip != (struct S61 *)NIL) {
  758.             sp = mksym(lfield);
  759.             sp->U.V6.lid = ip->U.V43.tsym->U.V6.lid;
  760.             sp->U.V6.lused = false;
  761.             sp->lsymdecl = ip;
  762.             declsym(sp);
  763.             ip = ip->tnext;
  764.         }
  765.         fp = fp->tnext;
  766.     }
  767.     vp = rp->U.V21.tvlist;
  768.     while (vp != (struct S61 *)NIL) {
  769.         addfields(vp->U.V20.tvrnt);
  770.         vp = vp->tnext;
  771.     }
  772. }
  773.  
  774.  void
  775. scopeup(tp)
  776.     treeptr    tp;
  777. {
  778.     addfields(typeof(tp));
  779. }
  780.  
  781.  treeptr
  782. newlbl()
  783. {
  784.     register treeptr    R126;
  785.     symptr    sp;
  786.     treeptr    tp;
  787.  
  788.     tp = mknode(nlabel);
  789.     sp = lookuplabel(currsym.U.V3.vint);
  790.     if (sp != (struct S62 *)NIL)
  791.         if (sp->ldecl != symtab)
  792.             sp = (struct S62 *)NIL;
  793.     if (sp == (struct S62 *)NIL) {
  794.         sp = mksym(lforwlab);
  795.         sp->U.V9.lno = currsym.U.V3.vint;
  796.         sp->U.V9.lgo = false;
  797.         sp->lsymdecl = tp;
  798.         declsym(sp);
  799.     } else
  800.         error(emultdecllab);
  801.     tp->U.V43.tsym = sp;
  802.     R126 = tp;
  803.     return R126;
  804. }
  805.  
  806.  treeptr
  807. oldlbl(defpt)
  808.     boolean    defpt;
  809. {
  810.     register treeptr    R127;
  811.     symptr    sp;
  812.     treeptr    tp;
  813.  
  814.     sp = lookuplabel(currsym.U.V3.vint);
  815.     if (sp == (struct S62 *)NIL) {
  816.         prtmsg(enotdecllab);
  817.         tp = newlbl();
  818.         sp = tp->U.V43.tsym;
  819.     } else {
  820.         tp = mknode(nlabel);
  821.         tp->U.V43.tsym = sp;
  822.     }
  823.     if (defpt) {
  824.         if (sp->lt == lforwlab)
  825.             sp->lt = llabel;
  826.         else
  827.             error(emuldeflab);
  828.     }
  829.     R127 = tp;
  830.     return R127;
  831. }
  832.  
  833.  void
  834. pbody(tp)
  835.     treeptr    tp;
  836. {
  837.     treeptr    tq;
  838.  
  839.     statlvl = statlvl + 1;
  840.     if (currsym.st == slabel) {
  841.         tp->U.V13.tsublab = plabel();
  842.         linkup(tp, tp->U.V13.tsublab);
  843.     } else
  844.         tp->U.V13.tsublab = (struct S61 *)NIL;
  845.     if (currsym.st == sconst) {
  846.         tp->U.V13.tsubconst = pconst();
  847.         linkup(tp, tp->U.V13.tsubconst);
  848.     } else
  849.         tp->U.V13.tsubconst = (struct S61 *)NIL;
  850.     if (currsym.st == stype) {
  851.         tp->U.V13.tsubtype = ptype();
  852.         linkup(tp, tp->U.V13.tsubtype);
  853.     } else
  854.         tp->U.V13.tsubtype = (struct S61 *)NIL;
  855.     if (currsym.st == svar) {
  856.         tp->U.V13.tsubvar = pvar();
  857.         linkup(tp, tp->U.V13.tsubvar);
  858.     } else
  859.         tp->U.V13.tsubvar = (struct S61 *)NIL;
  860.     tp->U.V13.tsubsub = (struct S61 *)NIL;
  861.     tq = (struct S61 *)NIL;
  862.     while ((currsym.st == sproc) || (currsym.st == sfunc)) {
  863.         if (tq == (struct S61 *)NIL) {
  864.             tq = psubs();
  865.             tp->U.V13.tsubsub = tq;
  866.         } else {
  867.             tq->tnext = psubs();
  868.             tq = tq->tnext;
  869.         }
  870.     }
  871.     linkup(tp, tp->U.V13.tsubsub);
  872.     checksymbol(*((symset *)Conset[6]));
  873.     if (currsym.st == sbegin) {
  874.         tp->U.V13.tsubstmt = pbegin(false);
  875.         linkup(tp, tp->U.V13.tsubstmt);
  876.     }
  877.     statlvl = statlvl - 1;
  878. }
  879.  
  880. treeptr pprogram();
  881.  
  882.  treeptr
  883. pprmlist()
  884. {
  885.     register treeptr    R129;
  886.     treeptr    tp, tq;
  887.     idptr    din, dut;
  888.  
  889.     tp = (struct S61 *)NIL;
  890.     din = deftab.A[(int)(dinput)]->U.V14.tidl->U.V43.tsym->U.V6.lid;
  891.     dut = deftab.A[(int)(doutput)]->U.V14.tidl->U.V43.tsym->U.V6.lid;
  892.     while ((currsym.U.V1.vid == din) || (currsym.U.V1.vid == dut)) {
  893.         if (currsym.U.V1.vid == din)
  894.             defnams.A[(int)(dinput)]->U.V6.lused = true;
  895.         else
  896.             defnams.A[(int)(doutput)]->U.V6.lused = true;
  897.         nextsymbol(*((symset *)Conset[7]));
  898.         if (currsym.st == srpar)
  899.             goto L999;
  900.         nextsymbol(*((symset *)Conset[8]));
  901.     }
  902.     tq = newid(currsym.U.V1.vid);
  903.     tq->U.V43.tsym->lt = lpointer;
  904.     tp = tq;
  905.     nextsymbol(*((symset *)Conset[9]));
  906.     while (currsym.st == scomma) {
  907.         nextsymbol(*((symset *)Conset[10]));
  908.         if (currsym.U.V1.vid == din)
  909.             defnams.A[(int)(dinput)]->U.V6.lused = true;
  910.         else
  911.             if (currsym.U.V1.vid == dut)
  912.                 defnams.A[(int)(doutput)]->U.V6.lused = true;
  913.             else {
  914.                 tq->tnext = newid(currsym.U.V1.vid);
  915.                 tq = tq->tnext;
  916.                 tq->U.V43.tsym->lt = lpointer;
  917.             }
  918.         nextsymbol(*((symset *)Conset[11]));
  919.     }
  920. L999:
  921.     R129 = tp;
  922.     return R129;
  923. }
  924.  
  925.  treeptr
  926. pprogram()
  927. {
  928.     register treeptr    R128;
  929.     treeptr    tp;
  930.  
  931.     enterscope((declptr)NIL);
  932.     tp = mknode(npgm);
  933.     nextsymbol(*((symset *)Conset[12]));
  934.     tp->U.V13.tstat = statlvl;
  935.     tp->U.V13.tsubid = mknode(nid);
  936.     tp->U.V13.tsubid->tup = tp;
  937.     tp->U.V13.tsubid->U.V43.tsym = mksym(lidentifier);
  938.     tp->U.V13.tsubid->U.V43.tsym->U.V6.lid = currsym.U.V1.vid;
  939.     tp->U.V13.tsubid->U.V43.tsym->lsymdecl = tp->U.V13.tsubid;
  940.     linkup(tp, tp->U.V13.tsubid);
  941.     nextsymbol(*((symset *)Conset[13]));
  942.     if (currsym.st == slpar) {
  943.         nextsymbol(*((symset *)Conset[14]));
  944.         tp->U.V13.tsubpar = pprmlist();
  945.         linkup(tp, tp->U.V13.tsubpar);
  946.         nextsymbol(*((symset *)Conset[15]));
  947.     } else
  948.         tp->U.V13.tsubpar = (struct S61 *)NIL;
  949.     nextsymbol(*((symset *)Conset[16]));
  950.     pbody(tp);
  951.     checksymbol(*((symset *)Conset[17]));
  952.     tp->U.V13.tscope = currscope();
  953.     leavescope();
  954.     R128 = tp;
  955.     return R128;
  956. }
  957.  
  958.  treeptr
  959. pmodule()
  960. {
  961.     register treeptr    R130;
  962.     treeptr    tp;
  963.  
  964.     enterscope((declptr)NIL);
  965.     tp = mknode(npgm);
  966.     tp->U.V13.tstat = statlvl;
  967.     tp->U.V13.tsubid = (struct S61 *)NIL;
  968.     tp->U.V13.tsubpar = (struct S61 *)NIL;
  969.     pbody(tp);
  970.     checksymbol(*((symset *)Conset[18]));
  971.     tp->U.V13.tscope = currscope();
  972.     leavescope();
  973.     R130 = tp;
  974.     return R130;
  975. }
  976.  
  977.  treeptr
  978. plabel()
  979. {
  980.     register treeptr    R131;
  981.     treeptr    tp, tq;
  982.  
  983.     tq = (struct S61 *)NIL;
  984.     do {
  985.         nextsymbol(*((symset *)Conset[19]));
  986.         if (tq == (struct S61 *)NIL) {
  987.             tq = newlbl();
  988.             tp = tq;
  989.         } else {
  990.             tq->tnext = newlbl();
  991.             tq = tq->tnext;
  992.         }
  993.         nextsymbol(*((symset *)Conset[20]));
  994.     } while (!(currsym.st == ssemic));
  995.     nextsymbol(*((symset *)Conset[21]));
  996.     R131 = tp;
  997.     return R131;
  998. }
  999.  
  1000.  treeptr
  1001. pidlist(l)
  1002.     ltypes    l;
  1003. {
  1004.     register treeptr    R132;
  1005.     treeptr    tp, tq;
  1006.  
  1007.     tq = newid(currsym.U.V1.vid);
  1008.     tq->U.V43.tsym->lt = l;
  1009.     tp = tq;
  1010.     nextsymbol(*((symset *)Conset[22]));
  1011.     while (currsym.st == scomma) {
  1012.         nextsymbol(*((symset *)Conset[23]));
  1013.         tq->tnext = newid(currsym.U.V1.vid);
  1014.         tq = tq->tnext;
  1015.         tq->U.V43.tsym->lt = l;
  1016.         nextsymbol(*((symset *)Conset[24]));
  1017.     }
  1018.     R132 = tp;
  1019.     return R132;
  1020. }
  1021.  
  1022.  treeptr
  1023. pconst()
  1024. {
  1025.     register treeptr    R133;
  1026.     treeptr    tp, tq;
  1027.  
  1028.     tq = (struct S61 *)NIL;
  1029.     nextsymbol(*((symset *)Conset[25]));
  1030.     do {
  1031.         if (tq == (struct S61 *)NIL) {
  1032.             tq = mknode(nconst);
  1033.             tq->U.V14.tattr = anone;
  1034.             tp = tq;
  1035.         } else {
  1036.             tq->tnext = mknode(nconst);
  1037.             tq = tq->tnext;
  1038.             tq->U.V14.tattr = anone;
  1039.         }
  1040.         tq->U.V14.tidl = pidlist(lidentifier);
  1041.         checksymbol(*((symset *)Conset[26]));
  1042.         nextsymbol(*((symset *)Conset[27]));
  1043.         tq->U.V14.tbind = pconstant(true);
  1044.         nextsymbol(*((symset *)Conset[28]));
  1045.         nextsymbol(*((symset *)Conset[29]));
  1046.     } while (!(currsym.st != sid));
  1047.     R133 = tp;
  1048.     return R133;
  1049. }
  1050.  
  1051.  treeptr
  1052. pconstant(realok)
  1053.     boolean    realok;
  1054. {
  1055.     register treeptr    R134;
  1056.     treeptr    tp, tq;
  1057.     boolean    neg;
  1058.  
  1059.     neg = (boolean)(currsym.st == sminus);
  1060.     if (Member((unsigned)(currsym.st), Conset[30]))
  1061.         if (realok)
  1062.             nextsymbol(*((symset *)Conset[31]));
  1063.         else
  1064.             nextsymbol(*((symset *)Conset[32]));
  1065.     if (currsym.st == sid)
  1066.         tp = oldid(currsym.U.V1.vid, lidentifier);
  1067.     else
  1068.         tp = mklit();
  1069.     if (neg) {
  1070.         tq = mknode(numinus);
  1071.         tq->U.V42.texps = tp;
  1072.         tp = tq;
  1073.     }
  1074.     R134 = tp;
  1075.     return R134;
  1076. }
  1077.  
  1078.  treeptr
  1079. precord(cs, dp)
  1080.     symtyp    cs;
  1081.     declptr    dp;
  1082. {
  1083.     register treeptr    R135;
  1084.     treeptr    tp, tq, tl, tv;
  1085.     lexsym    tsym;
  1086.  
  1087.     tp = mknode(nrecord);
  1088.     tp->U.V21.tflist = (struct S61 *)NIL;
  1089.     tp->U.V21.tvlist = (struct S61 *)NIL;
  1090.     tp->U.V21.tuid = (struct S59 *)NIL;
  1091.     tp->U.V21.trscope = (struct S60 *)NIL;
  1092.     if (cs == send) {
  1093.         enterscope(dp);
  1094.         dp = currscope();
  1095.     }
  1096.     nextsymbol(*((symset *)Union(Conset[33], Saveset((Tmpset = Newset(), (void)Insmem((unsigned)(cs), Tmpset), Tmpset)))));
  1097.     Claimset();
  1098.     tq = (struct S61 *)NIL;
  1099.     while (currsym.st == sid) {
  1100.         if (tq == (struct S61 *)NIL) {
  1101.             tq = mknode(nfield);
  1102.             tq->U.V14.tattr = anone;
  1103.             tp->U.V21.tflist = tq;
  1104.         } else {
  1105.             tq->tnext = mknode(nfield);
  1106.             tq = tq->tnext;
  1107.             tq->U.V14.tattr = anone;
  1108.         }
  1109.         tq->U.V14.tidl = pidlist(lfield);
  1110.         checksymbol(*((symset *)Conset[34]));
  1111.         leavescope();
  1112.         tq->U.V14.tbind = ptypedef();
  1113.         enterscope(dp);
  1114.         if (currsym.st == ssemic)
  1115.             nextsymbol(*((symset *)Union(Conset[35], Saveset((Tmpset = Newset(), (void)Insmem((unsigned)(cs), Tmpset), Tmpset)))));
  1116.         Claimset();
  1117.     }
  1118.     if (currsym.st == scase) {
  1119.         nextsymbol(*((symset *)Conset[36]));
  1120.         tsym = currsym;
  1121.         nextsymbol(*((symset *)Conset[37]));
  1122.         if (currsym.st == scolon) {
  1123.             tv = newid(tsym.U.V1.vid);
  1124.             if (tq == (struct S61 *)NIL) {
  1125.                 tq = mknode(nfield);
  1126.                 tp->U.V21.tflist = tq;
  1127.             } else {
  1128.                 tq->tnext = mknode(nfield);
  1129.                 tq = tq->tnext;
  1130.             }
  1131.             tq->U.V14.tidl = tv;
  1132.             tv->U.V43.tsym->lt = lfield;
  1133.             nextsymbol(*((symset *)Conset[38]));
  1134.             leavescope();
  1135.             tq->U.V14.tbind = oldid(currsym.U.V1.vid, lidentifier);
  1136.             enterscope(dp);
  1137.             nextsymbol(*((symset *)Conset[39]));
  1138.         }
  1139.         tq = (struct S61 *)NIL;
  1140.         do {
  1141.             tv = (struct S61 *)NIL;
  1142.             do {
  1143.                 nextsymbol(*((symset *)Union(Conset[40], Saveset((Tmpset = Newset(), (void)Insmem((unsigned)(cs), Tmpset), Tmpset)))));
  1144.                 Claimset();
  1145.                 if (currsym.st == cs)
  1146.                     goto L999;
  1147.                 if (tv == (struct S61 *)NIL) {
  1148.                     tv = pconstant(false);
  1149.                     tl = tv;
  1150.                 } else {
  1151.                     tv->tnext = pconstant(false);
  1152.                     tv = tv->tnext;
  1153.                 }
  1154.                 nextsymbol(*((symset *)Conset[41]));
  1155.             } while (!(currsym.st == scolon));
  1156.             nextsymbol(*((symset *)Conset[42]));
  1157.             if (tq == (struct S61 *)NIL) {
  1158.                 tq = mknode(nvariant);
  1159.                 tp->U.V21.tvlist = tq;
  1160.             } else {
  1161.                 tq->tnext = mknode(nvariant);
  1162.                 tq = tq->tnext;
  1163.             }
  1164.             tq->U.V20.tselct = tl;
  1165.             tq->U.V20.tvrnt = precord(srpar, dp);
  1166.         } while (!(currsym.st == cs));
  1167.     }
  1168. L999:
  1169.     if (cs == send) {
  1170.         tp->U.V21.trscope = dp;
  1171.         leavescope();
  1172.     }
  1173.     nextsymbol(*((symset *)Conset[43]));
  1174.     R135 = tp;
  1175.     return R135;
  1176. }
  1177.  
  1178.  treeptr
  1179. ptypedef()
  1180. {
  1181.     register treeptr    R136;
  1182.     treeptr    tp, tq;
  1183.     symtyp    st;
  1184.     symset    ss;
  1185.  
  1186.     nextsymbol(*((symset *)Conset[44]));
  1187.     if (currsym.st == spacked)
  1188.         nextsymbol(*((symset *)Conset[45]));
  1189.     Setncpy(ss.S, Conset[46], sizeof(ss.S));
  1190.     switch (currsym.st) {
  1191.       case splus:  case sminus:  case schar:  case sinteger:
  1192.       case sid:
  1193.         st = currsym.st;
  1194.         tp = pconstant(false);
  1195.         if (st == sid)
  1196.             nextsymbol(*((symset *)Union(Conset[47], ss.S)));
  1197.         else
  1198.             nextsymbol(*((symset *)Conset[48]));
  1199.         Claimset();
  1200.         if (currsym.st == sdotdot) {
  1201.             nextsymbol(*((symset *)Conset[49]));
  1202.             tq = mknode(nsubrange);
  1203.             tq->U.V19.tlo = tp;
  1204.             tq->U.V19.thi = pconstant(false);
  1205.             tp = tq;
  1206.             nextsymbol(ss);
  1207.         }
  1208.         break ;
  1209.       case slpar:
  1210.         tp = mknode(nscalar);
  1211.         nextsymbol(*((symset *)Conset[50]));
  1212.         tp->U.V17.tscalid = pidlist(lidentifier);
  1213.         checksymbol(*((symset *)Conset[51]));
  1214.         nextsymbol(ss);
  1215.         break ;
  1216.       case sarrow:
  1217.         tp = mknode(nptr);
  1218.         nextsymbol(*((symset *)Conset[52]));
  1219.         tp->U.V16.tptrid = oldid(currsym.U.V1.vid, lpointer);
  1220.         tp->U.V16.tptrflag = false;
  1221.         nextsymbol(*((symset *)Conset[53]));
  1222.         break ;
  1223.       case sarray:
  1224.         nextsymbol(*((symset *)Conset[54]));
  1225.         tp = mknode(narray);
  1226.         tp->U.V23.taindx = ptypedef();
  1227.         tq = tp;
  1228.         while (currsym.st == scomma) {
  1229.             tq->U.V23.taelem = mknode(narray);
  1230.             tq = tq->U.V23.taelem;
  1231.             tq->U.V23.taindx = ptypedef();
  1232.         }
  1233.         checksymbol(*((symset *)Conset[55]));
  1234.         nextsymbol(*((symset *)Conset[56]));
  1235.         tq->U.V23.taelem = ptypedef();
  1236.         break ;
  1237.       case srecord:
  1238.         tp = precord(send, (declptr)NIL);
  1239.         break ;
  1240.       case sfile:  case sset:
  1241.         if (currsym.st == sfile)
  1242.             tp = mknode(nfileof);
  1243.         else {
  1244.             tp = mknode(nsetof);
  1245.             usesets = true;
  1246.         }
  1247.         nextsymbol(*((symset *)Conset[57]));
  1248.         tp->U.V18.tof = ptypedef();
  1249.         break ;
  1250.       default:
  1251.         Caseerror(Line);
  1252.     }
  1253.     R136 = tp;
  1254.     return R136;
  1255. }
  1256.  
  1257.  treeptr
  1258. ptype()
  1259. {
  1260.     register treeptr    R137;
  1261.     treeptr    tp, tq;
  1262.  
  1263.     tq = (struct S61 *)NIL;
  1264.     nextsymbol(*((symset *)Conset[58]));
  1265.     do {
  1266.         if (tq == (struct S61 *)NIL) {
  1267.             tq = mknode(ntype);
  1268.             tq->U.V14.tattr = anone;
  1269.             tp = tq;
  1270.         } else {
  1271.             tq->tnext = mknode(ntype);
  1272.             tq = tq->tnext;
  1273.             tq->U.V14.tattr = anone;
  1274.         }
  1275.         tq->U.V14.tidl = pidlist(lidentifier);
  1276.         checksymbol(*((symset *)Conset[59]));
  1277.         tq->U.V14.tbind = ptypedef();
  1278.         nextsymbol(*((symset *)Conset[60]));
  1279.     } while (!(currsym.st != sid));
  1280.     R137 = tp;
  1281.     return R137;
  1282. }
  1283.  
  1284.  treeptr
  1285. pvar()
  1286. {
  1287.     register treeptr    R138;
  1288.     treeptr    ti, tp, tq;
  1289.  
  1290.     tq = (struct S61 *)NIL;
  1291.     nextsymbol(*((symset *)Conset[61]));
  1292.     do {
  1293.         if (tq == (struct S61 *)NIL) {
  1294.             tq = mknode(nvar);
  1295.             tq->U.V14.tattr = anone;
  1296.             tp = tq;
  1297.         } else {
  1298.             tq->tnext = mknode(nvar);
  1299.             tq = tq->tnext;
  1300.             tq->U.V14.tattr = anone;
  1301.         }
  1302.         ti = newid(currsym.U.V1.vid);
  1303.         tq->U.V14.tidl = ti;
  1304.         nextsymbol(*((symset *)Conset[62]));
  1305.         while (currsym.st == scomma) {
  1306.             nextsymbol(*((symset *)Conset[63]));
  1307.             ti->tnext = newid(currsym.U.V1.vid);
  1308.             ti = ti->tnext;
  1309.             nextsymbol(*((symset *)Conset[64]));
  1310.         }
  1311.         tq->U.V14.tbind = ptypedef();
  1312.         nextsymbol(*((symset *)Conset[65]));
  1313.     } while (!(currsym.st != sid));
  1314.     R138 = tp;
  1315.     return R138;
  1316. }
  1317.  
  1318.  treeptr
  1319. psubs()
  1320. {
  1321.     register treeptr    R139;
  1322.     treeptr    tp, tv, tq;
  1323.     boolean    func;
  1324.     symtyp    colsem;
  1325.  
  1326.     func = (boolean)(currsym.st == sfunc);
  1327.     if (func)
  1328.         colsem = scolon;
  1329.     else
  1330.         colsem = ssemic;
  1331.     nextsymbol(*((symset *)Conset[66]));
  1332.     tq = newid(currsym.U.V1.vid);
  1333.     if (tq->tup == (struct S61 *)NIL) {
  1334.         enterscope((declptr)NIL);
  1335.         if (func)
  1336.             tp = mknode(nfunc);
  1337.         else
  1338.             tp = mknode(nproc);
  1339.         tp->U.V13.tstat = statlvl;
  1340.         tp->U.V13.tsubid = tq;
  1341.         linkup(tp, tq);
  1342.         nextsymbol(*((symset *)(Tmpset = Newset(), (void)Insmem((unsigned)(slpar), Tmpset),
  1343.             (void)Insmem((unsigned)(colsem), Tmpset), Tmpset)));
  1344.         if (currsym.st == slpar) {
  1345.             tp->U.V13.tsubpar = psubpar();
  1346.             linkup(tp, tp->U.V13.tsubpar);
  1347.             nextsymbol(*((symset *)(Tmpset = Newset(), (void)Insmem((unsigned)(colsem), Tmpset), Tmpset)));
  1348.         } else
  1349.             tp->U.V13.tsubpar = (struct S61 *)NIL;
  1350.         if (func) {
  1351.             nextsymbol(*((symset *)Conset[67]));
  1352.             tp->U.V13.tfuntyp = oldid(currsym.U.V1.vid, lidentifier);
  1353.             nextsymbol(*((symset *)Conset[68]));
  1354.         } else
  1355.             tp->U.V13.tfuntyp = mknode(nempty);
  1356.         linkup(tp, tp->U.V13.tfuntyp);
  1357.         nextsymbol(*((symset *)Conset[69]));
  1358.     } else {
  1359.         enterscope(tq->tup->U.V13.tscope);
  1360.         if (func)
  1361.             tp = mknode(nfunc);
  1362.         else
  1363.             tp = mknode(nproc);
  1364.         tp->U.V13.tfuntyp = tq->tup->U.V13.tfuntyp;
  1365.         tv = tq->tup->U.V13.tsubpar;
  1366.         tp->U.V13.tsubpar = tv;
  1367.         while (tv != (struct S61 *)NIL) {
  1368.             tv->tup = tp;
  1369.             tv = tv->tnext;
  1370.         }
  1371.         tp->U.V13.tsubid = tq;
  1372.         tq->tup = tp;
  1373.         nextsymbol(*((symset *)Conset[70]));
  1374.         nextsymbol(*((symset *)Conset[71]));
  1375.     }
  1376.     if (Member((unsigned)(currsym.st), Conset[72])) {
  1377.         tp->U.V13.tsubid->U.V43.tsym->lt = lforward;
  1378.         nextsymbol(*((symset *)Conset[73]));
  1379.         tp->U.V13.tsublab = (struct S61 *)NIL;
  1380.         tp->U.V13.tsubconst = (struct S61 *)NIL;
  1381.         tp->U.V13.tsubtype = (struct S61 *)NIL;
  1382.         tp->U.V13.tsubvar = (struct S61 *)NIL;
  1383.         tp->U.V13.tsubsub = (struct S61 *)NIL;
  1384.         tp->U.V13.tsubstmt = (struct S61 *)NIL;
  1385.     } else
  1386.         pbody(tp);
  1387.     nextsymbol(*((symset *)Conset[74]));
  1388.     tp->U.V13.tscope = currscope();
  1389.     leavescope();
  1390.     R139 = tp;
  1391.     return R139;
  1392. }
  1393.  
  1394.  treeptr
  1395. pconfsub()
  1396. {
  1397.     register treeptr    R140;
  1398.     treeptr    tp;
  1399.  
  1400.     tp = mknode(nsubrange);
  1401.     nextsymbol(*((symset *)Conset[75]));
  1402.     tp->U.V19.tlo = newid(currsym.U.V1.vid);
  1403.     nextsymbol(*((symset *)Conset[76]));
  1404.     nextsymbol(*((symset *)Conset[77]));
  1405.     tp->U.V19.thi = newid(currsym.U.V1.vid);
  1406.     nextsymbol(*((symset *)Conset[78]));
  1407.     R140 = tp;
  1408.     return R140;
  1409. }
  1410.  
  1411.  treeptr
  1412. pconform()
  1413. {
  1414.     register treeptr    R141;
  1415.     treeptr    tp, tq;
  1416.  
  1417.     nextsymbol(*((symset *)Conset[79]));
  1418.     tp = mknode(nconfarr);
  1419.     tp->U.V22.tcuid = mkvariable('S');
  1420.     tp->U.V22.tcindx = pconfsub();
  1421.     nextsymbol(*((symset *)Conset[80]));
  1422.     tp->U.V22.tindtyp = oldid(currsym.U.V1.vid, lidentifier);
  1423.     nextsymbol(*((symset *)Conset[81]));
  1424.     tq = tp;
  1425.     while (currsym.st == ssemic) {
  1426.         error(econfconf);
  1427.         tq->U.V22.tcelem = mknode(nconfarr);
  1428.         tq = tq->U.V22.tcelem;
  1429.         tq->U.V22.tcindx = pconfsub();
  1430.         nextsymbol(*((symset *)Conset[82]));
  1431.         tq->U.V22.tindtyp = oldid(currsym.U.V1.vid, lidentifier);
  1432.         nextsymbol(*((symset *)Conset[83]));
  1433.     }
  1434.     nextsymbol(*((symset *)Conset[84]));
  1435.     nextsymbol(*((symset *)Conset[85]));
  1436.     switch (currsym.st) {
  1437.       case sid:
  1438.         tq->U.V22.tcelem = oldid(currsym.U.V1.vid, lidentifier);
  1439.         break ;
  1440.       case sarray:
  1441.         error(econfconf);
  1442.         tq->U.V22.tcelem = pconform();
  1443.         break ;
  1444.       default:
  1445.         Caseerror(Line);
  1446.     }
  1447.     R141 = tp;
  1448.     return R141;
  1449. }
  1450.  
  1451.  treeptr
  1452. psubpar()
  1453. {
  1454.     register treeptr    R142;
  1455.     treeptr    tp, tq;
  1456.     treetyp    nt;
  1457.  
  1458.     tq = (struct S61 *)NIL;
  1459.     do {
  1460.         nextsymbol(*((symset *)Conset[86]));
  1461.         switch (currsym.st) {
  1462.           case sid:
  1463.             nt = nvalpar;
  1464.             break ;
  1465.           case svar:
  1466.             nt = nvarpar;
  1467.             break ;
  1468.           case sfunc:
  1469.             nt = nparfunc;
  1470.             break ;
  1471.           case sproc:
  1472.             nt = nparproc;
  1473.             break ;
  1474.           default:
  1475.             Caseerror(Line);
  1476.         }
  1477.         if (nt != nvalpar)
  1478.             nextsymbol(*((symset *)Conset[87]));
  1479.         if (tq == (struct S61 *)NIL) {
  1480.             tq = mknode(nt);
  1481.             tp = tq;
  1482.         } else {
  1483.             tq->tnext = mknode(nt);
  1484.             tq = tq->tnext;
  1485.         }
  1486.         switch (nt) {
  1487.           case nvarpar:  case nvalpar:
  1488.             tq->U.V14.tidl = pidlist(lidentifier);
  1489.             tq->U.V14.tattr = anone;
  1490.             checksymbol(*((symset *)Conset[88]));
  1491.             if (nt == nvalpar)
  1492.                 nextsymbol(*((symset *)Conset[89]));
  1493.             else
  1494.                 nextsymbol(*((symset *)Conset[90]));
  1495.             switch (currsym.st) {
  1496.               case sid:
  1497.                 tq->U.V14.tbind = oldid(currsym.U.V1.vid, lidentifier);
  1498.                 break ;
  1499.               case sarray:
  1500.                 tq->U.V14.tbind = pconform();
  1501.